// websocket实例
let wsObj = null;
// websocket连接地址
let wsUrl = null;
// 是否执行重连 true/不执行 ； false/执行
let lockReconnect = false;
// 重连定时器
let wsCreateHandler = null;
// 连接成功，执行回调函数
let messageCallback = null;
// 连接失败，执行回调函数
let errorCallback = null;
// 发送给后台的数据
let sendDatas = {};
// 用户ID (用于后台鉴别不同用户的唯一key)
let userId = null;
 
 
/**
 * 发起 websocket请求函数
 * @param {string} url ws连接地址
 * @param {Object} agentData 传给后台的参数
 * @param {function} successCallback 接收到ws数据，对数据进行处理的回调函数
 * @param {function} errCallback ws连接错误的回调函数
 */
export const connectWebsocket = (url, agentData, user, successCallback, errCallback) => {
  wsUrl = url;
  createWebSoket();
  messageCallback = successCallback;
  errorCallback = errCallback;
  sendDatas = agentData;
  userId = user;
}
 
// 手动关闭websocket （这里手动关闭会执行onclose事件）
export const closeWebsocket = () => {
  if (wsObj) {
    writeToScreen('手动关闭websocket');
    wsObj.close() // 关闭websocket
    // wsObj.onclose() // 关闭websocket(如果上面的关闭不生效就加上这一条)
    // 关闭重连
    lockReconnect = true;
    wsCreateHandler && clearTimeout(wsCreateHandler);
    // 关闭心跳检查
    heartCheck.stop();
  }
}
 
// 创建ws函数
const createWebSoket = () => {
  if (typeof (WebSocket) === 'undefined') {
    writeToScreen("您的浏览器不支持WebSocket，无法获取数据");
    return false
  }
 
  try {
	// 生成新的wsObj实例
    wsObj = new WebSocket(wsUrl);
    initWsEventHandle();
  } catch (e) {
    writeToScreen("连接异常，开始重连");
    reconnect();
  }
}
 
// 重写websocket的各种函数
const initWsEventHandle = () => {
  try {
    // 连接成功
    wsObj.onopen = (event) => {
      onWsOpen(event);
      heartCheck.start();
    }
 
    // 监听服务器端返回的信息
    wsObj.onmessage = (event) => {
      onWsMessage(event);
      heartCheck.start();
    }
 
    wsObj.onclose = (event) => {
      writeToScreen('onclose执行关闭事件');
      onWsClose(event);
    }
 
    wsObj.onerror = (event) => {
      writeToScreen('onerror执行error事件，开始重连');
      onWsError(event);
      reconnect();
    }
  } catch (err) {
    writeToScreen('绑定事件没有成功，开始重连');
    reconnect();
  }
}
 
// 开启时
const onWsOpen = (event) => {
  writeToScreen('CONNECT');
  // // 客户端与服务器端通信
  // 添加状态判断，当为OPEN时，发送消息
  if (wsObj.readyState === 1) { // wsObj.OPEN = 1 
    // 发给后端的数据需要字符串化
    wsObj.send(JSON.stringify(sendDatas));
  }
  if (wsObj.readyState === 3) { // wsObj.CLOSED = 3 
    writeToScreen('wsObj.readyState=3, ws连接异常，开始重连');
    reconnect();
    errorCallback(event);
  }
}
// 收到消息时
const onWsMessage = (event) => {
	console.log(event);
	if(event.data){
		const result =JSON.parse(event.data)
		
		//writeToScreen('onWsMessage接收到服务器的数据: ', jsonStr);
		messageCallback(result);
	}
  
}
// 关闭时
const onWsClose = (event) => {
  writeToScreen('DISCONNECT');
  // e.code === 1000  表示正常关闭。 无论为何目的而创建, 该链接都已成功完成任务。
  // e.code !== 1000  表示非正常关闭。
  console.log('onclose event: ', event)
  if (event && event.code !== 1000) {
    writeToScreen('非正常关闭');
    errorCallback(event);
    // 如果不是手动关闭，这里的重连会执行；如果调用了手动关闭函数，这里重连不会执行
    reconnect();
  }
}
// 错误时
const onWsError = (event) => {
  writeToScreen('onWsError: ', event.data);
  errorCallback(event);
}
 
const writeToScreen = (massage) => {
  console.log(massage);
}
 
// 重连函数
const reconnect = () => {
  if (lockReconnect) {
    return;
  }
  writeToScreen('3秒后重连');
  lockReconnect = true;
  // 没连接上会一直重连，设置延迟避免请求过多
  wsCreateHandler && clearTimeout(wsCreateHandler);
  wsCreateHandler = setTimeout(() => {
    writeToScreen('重连...' + wsUrl);
    createWebSoket();
    lockReconnect = false;
    writeToScreen('重连完成');
  }, 3000);
}
 
// 心跳检查（看看websocket是否还在正常连接中）
let heartCheck = {
  timeout: 15000,
  timeoutObj: null,
  serverTimeoutObj: null,
  // 重启
  reset() {
    clearTimeout(this.timeoutObj);
    clearTimeout(this.serverTimeoutObj);
    this.start();
  },
  // 停止
  stop() {
    clearTimeout(this.timeoutObj);
    clearTimeout(this.serverTimeoutObj);
  },
  // 开启定时器
  start() {
    // this.timeoutObj && clearTimeout(this.timeoutObj);
    // this.serverTimeoutObj && clearTimeout(this.serverTimeoutObj);
    // // 15s之内如果没有收到后台的消息，则认为是连接断开了，需要重连
    // this.timeoutObj = setTimeout(() => {
    //   writeToScreen("心跳检查，发送ping到后台");
    //   try {
    //     // const datas = { ping: true, msg: "客户端普通心跳检测", userId: userId};
    //     const datas = {};
    //     wsObj.send(JSON.stringify(datas));
    //   } catch (err) {
    //     writeToScreen("发送ping异常");
    //   }
    //   // 内嵌定时器
    //   this.serverTimeoutObj = setTimeout(() => {
    //     reconnect();
    //   }, this.timeout)
    // }, this.timeout)
  }
}
 
export default{
	connectWebsocket
}


// class websocketUtil {
// 	constructor(url, time) {
// 		this.is_open_socket = false //避免重复连接
// 		this.url = url //地址
// 		this.data = null
// 		//心跳检测
// 		this.timeout= time //多少秒执行检测
// 		this.heartbeatInterval= null //检测服务器端是否还活着
// 		this.reconnectTimeOut= null //重连之后多久再次重连

// 		try {
// 			return this.connectSocketInit()
// 		} catch (e) {
// 			console.log('catch');
// 			this.is_open_socket = false
// 			this.reconnect();
// 		}
// 	}

// 	// 进入这个页面的时候创建websocket连接【整个页面随时使用】
// 	connectSocketInit() {
// 		this.socketTask = uni.connectSocket({
// 			url: this.url,
// 			success:()=>{
// 				console.log("正准备建立websocket中...");
// 				// 返回实例
// 				return this.socketTask
// 			},
// 		});
// 		this.socketTask.onOpen((res) => {
// 			console.log("WebSocket连接正常！");
// 			clearTimeout(this.reconnectTimeOut)
// 			clearTimeout(this.heartbeatInterval)
// 			this.is_open_socket = true;
// 			this.start();
// 			// 注：只有连接正常打开中 ，才能正常收到消息
// 			this.socketTask.onMessage((res) => {
// 				console.log(res.data)
// 			});
// 		})
// 		// 监听连接失败，这里代码我注释掉的原因是因为如果服务器关闭后，和下面的onclose方法一起发起重连操作，这样会导致重复连接
// 		// uni.onSocketError((res) => {
// 		// 	console.log('WebSocket连接打开失败，请检查！');
// 		// 	this.is_open_socket = false;
// 		// 	this.reconnect();
// 		// });
// 		// 这里仅是事件监听【如果socket关闭了会执行】
// 		this.socketTask.onClose(() => {
// 			console.log("已经被关闭了")
// 			this.is_open_socket = false;
// 			this.reconnect();
// 		})
// 	}
	
// 	//发送消息
// 	send(value){
// 		// 注：只有连接正常打开中 ，才能正常成功发送消息
// 		this.socketTask.send({
// 			data: value,
// 			async success() {
// 				console.log("消息发送成功");
// 			},
// 		});
// 	}
// 	//开启心跳检测
// 	start(){
// 		this.heartbeatInterval = setTimeout(()=>{
// 			this.data={value:"传输内容",method:"方法名称"}
// 			console.log(this.data)
// 			this.send(JSON.stringify(this.data));
// 		},this.timeout)
// 	}
// 	//重新连接
// 	reconnect(){
// 		//停止发送心跳
// 		clearInterval(this.heartbeatInterval)
// 		//如果不是人为关闭的话，进行重连
// 		if(!this.is_open_socket){
// 			this.reconnectTimeOut = setTimeout(()=>{
// 				this.connectSocketInit();
// 			},3000)
// 		}
// 	}
// 	//外部获取消息
// 	getMessage(callback) {
// 		this.socketTask.onMessage((res) => {
// 			return callback(res)
// 		})
// 	}
 
// }

// module.exports = websocketUtil